In [2]:

    

import codecs
with codecs.open("imdb_labelled.txt", "r",  "utf-8") as arquivo:
    vetor = []
    for linha in arquivo:
        vetor.append(linha)
with codecs.open("amazon_cells_labelled.txt", "r",  "utf-8") as arquivo:
    for linha in arquivo:
        vetor.append(linha)
with codecs.open("yelp_labelled.txt", "r",  "utf-8") as arquivo:
    for linha in arquivo:
        vetor.append(linha)


    

In [3]:

    

vetor = [ x[:-1] for x in vetor ]

import nltk

vetor = ([s.replace('&', '').replace(' - ', '').replace('.', '').replace(',', '').replace('!', '').
          replace('+', '')for s in vetor])


    

In [4]:

    

TextosQuebrados = [ x[:-4] for x in vetor ]

TextosQuebrados = map(lambda X:X.lower(),TextosQuebrados)

#TextosQuebrados = [x.split(' ') for x in TextosQuebrados]

TextosQuebrados = [nltk.tokenize.word_tokenize(frase) for frase in TextosQuebrados]

#X[0]


    

In [5]:

    

import nltk
stopwords = nltk.corpus.stopwords.words('english')

stemmer = nltk.stem.RSLPStemmer()

dicionario = set()

for comentarios in TextosQuebrados:
    validas = [stemmer.stem(palavra) for palavra in comentarios if palavra not in stopwords and len(palavra) > 0]
    dicionario.update(validas)

    
totalDePalavras = len(dicionario)
tuplas = zip(dicionario, xrange(totalDePalavras))
tradutor = {palavra:indice for palavra,indice in tuplas}
        
def vetorizar_texto(texto, tradutor, stemmer):
    vetor = [0] * len(tradutor)
    for palavra in texto:
        if len(palavra) > 0:
            raiz = stemmer.stem(palavra)
            if raiz in tradutor:
                posicao = tradutor[raiz]
                vetor[posicao] += 1

    return vetor

vetoresDeTexto = [vetorizar_texto(texto, tradutor,stemmer) for texto in TextosQuebrados]
X = vetoresDeTexto


    

In [6]:

    

Y = [ x[-1:] for x in vetor ]
len(Y)


    

    
Out[6]:





3002

In [7]:

    

porcentagem_de_treino = 0.8

tamanho_do_treino = porcentagem_de_treino * len(Y)
tamanho_de_validacao = len(Y) - tamanho_do_treino

treino_dados = X[0:int(tamanho_do_treino)]
treino_marcacoes = Y[0:int(tamanho_do_treino)]

validacao_dados = X[int(tamanho_do_treino):]
validacao_marcacoes = Y[int(tamanho_do_treino):]

fim_de_teste = tamanho_do_treino + tamanho_de_validacao
teste_dados = X[int(tamanho_do_treino):int(fim_de_teste)]
teste_marcacoes = Y[int(tamanho_do_treino):int(fim_de_teste)]


    

In [8]:

    

""""from sklearn import svm
from sklearn.model_selection import cross_val_score
k = 10

# Implement poly SVC 
poly_svc = svm.SVC(kernel='linear')
accuracy_poly_svc = cross_val_score(poly_svc, treino_dados, treino_marcacoes, cv=k, scoring='accuracy')
print('poly_svc: ', accuracy_poly_svc.mean())""""


    

    




  File "<ipython-input-8-ec94ce357cd1>", line 8
    print('poly_svc: ', accuracy_poly_svc.mean())""""
                                                     
^
SyntaxError: EOL while scanning string literal

In [9]:

    

def fit_and_predict(nome, modelo, treino_dados, treino_marcacoes, teste_dados, teste_marcacoes):
	modelo.fit(treino_dados, treino_marcacoes)

	resultado = modelo.predict(teste_dados)
	acertos = (resultado == teste_marcacoes)

	total_de_acertos = sum(acertos)
	total_de_elementos = len(teste_dados)
	taxa_de_acerto = float(total_de_acertos) / float(total_de_elementos)

	print(taxa_de_acerto)
	return taxa_de_acerto


resultados = {}

from sklearn.naive_bayes import MultinomialNB
modeloMultinomial = MultinomialNB()

from sklearn.ensemble import AdaBoostClassifier
clf = AdaBoostClassifier(n_estimators=100)

resultadoMultinomial = fit_and_predict("MultinomialNB", AdaBoostClassifier(n_estimators=100), treino_dados, treino_marcacoes, teste_dados, teste_marcacoes)
resultados[resultadoMultinomial] = modeloMultinomial


    

    




0.527454242928

In [ ]: